package com.mini.grpc.serialization.protobuf;

import com.mini.grpc.serialization.Marshaller;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * ProtobufLiteMarshaller实现了一个简化版的"Protobuf"序列化和反序列化。
 * 
 * <p>注意：这不是真正的Protobuf实现，而是使用Java序列化作为简化替代。
 * 在实际项目中，应该使用真正的Protobuf库。
 *
 * @param <T> 要序列化和反序列化的对象类型
 */
public class ProtobufLiteMarshaller<T extends Serializable> implements Marshaller<T> {
    
    private final Class<T> clazz;
    
    /**
     * 创建一个新的ProtobufLiteMarshaller
     *
     * @param clazz 要序列化和反序列化的对象类型
     */
    public ProtobufLiteMarshaller(Class<T> clazz) {
        this.clazz = clazz;
    }
    
    @Override
    public InputStream stream(T value) {
        try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
             ObjectOutputStream oos = new ObjectOutputStream(baos)) {
            oos.writeObject(value);
            oos.flush();
            return new ByteArrayInputStream(baos.toByteArray());
        } catch (IOException e) {
            throw new RuntimeException("Failed to serialize object", e);
        }
    }
    
    @Override
    @SuppressWarnings("unchecked")
    public T parse(InputStream stream) {
        try (ObjectInputStream ois = new ObjectInputStream(stream)) {
            return (T) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            throw new RuntimeException("Failed to deserialize object", e);
        }
    }
    
    /**
     * 创建一个新的ProtobufLiteMarshaller
     *
     * @param clazz 要序列化和反序列化的对象类型
     * @param <T> 对象类型
     * @return 新的ProtobufLiteMarshaller
     */
    public static <T extends Serializable> ProtobufLiteMarshaller<T> of(Class<T> clazz) {
        return new ProtobufLiteMarshaller<>(clazz);
    }
} 